home *** CD-ROM | disk | FTP | other *** search
/ TPUG - Toronto PET Users Group / TPUG Users Group CD / TPUG Users Group CD.iso / AMIGA / AMICUS / AMICUS12.ADF / C / vsprite / mygeltools.c < prev    next >
C/C++ Source or Header  |  1986-08-05  |  15KB  |  427 lines
  1.  
  2.  
  3. #include <exec/types.h>
  4. #include <exec/exec.h>
  5. #include <graphics/gfxmacros.h>
  6. #include <graphics/gels.h>
  7. #include <graphics/collide.h>
  8. #include <intuition/intuition.h>
  9.  
  10.  
  11. /*******************************************************************************
  12.  * This file is a collection of tools which are used with the vsprite and
  13.  * bob software.  It contains the following:
  14.  *
  15.  * ReadyGels( *gelsinfo, *rastport );
  16.  * PurgeGels( *gelsinfo );
  17.  *
  18.  * struct VSprite *MakeVSprite(lineheight,*image,*colorset,x,y,
  19.  *    wordwidth,imagedepth,flags);       
  20.  * DeleteVSprite( &VSprite );
  21.  *
  22.  * struct Bob *MakeBob(bitwidth,lineheight,imagedepth,*image,
  23.  *       planePick,planeOnOff,x,y)
  24.  * DeleteBob( &Bob );
  25.  *
  26.  * ReadyGels sets up the defaults of the gel system by initializing the
  27.  * GelsInfo structure you provide.  First it allocates room for and
  28.  * links in lastcolor and nextline. It then uses information in your
  29.  * RastPort structure to establish boundary collision defaults at
  30.  * the outer edges of the raster.  It then links together the GelsInfo
  31.  * and the RastPort which you provide. Next it allocates space for two
  32.  * dummy virtual sprite structures, calls InitGels and SetCollision.
  33.  ! You must already have run LoadView before ReadyGels is called.
  34.  *
  35.  * PurgeGels deallocates all memory which ReadyGels and NewGelList have
  36.  * allocated.  The system will crash if you have not used these
  37.  * routines to allocate the space (you cant deallocate something
  38.  * which you havent allocated in the first place).
  39.  *
  40.  * MakeVSprite allocates enough space for and inits a normal vsprite.
  41.  * DeleteVSprite deallocates the memory it used.
  42.  *
  43.  * MakeBob initializes a standard bob and allocates as much memory as is needed
  44.  * for a normal bob and its vsprite structure, links them together.
  45.  * To find the associated vsprite, look at the back-pointer (see the
  46.  * routine doc itself).
  47.  * DeleteBob deallocates the memory it used.
  48.  *
  49.  * Written by Rob Peck, with thanks to Barry Whitebrook and David Lucas.
  50.  *
  51.  ******************************************************************************/
  52.  
  53. void border_dummy()
  54. { 
  55.    return; 
  56. }
  57.  
  58. /* Caller passes a pointer to his GelsInfo structure which he wants to init, 
  59.  * along with a pointer to his IVPArgs.  Default init places the topmost
  60.  * bottommost etc at the outermost boundaries of callers rastport parameters.
  61.  */
  62.  
  63. extern struct RastPort *myRast;
  64.  
  65. struct VSprite *SpriteHead = NULL;
  66. struct VSprite *SpriteTail = NULL;
  67.  
  68. /*******************************************************************************
  69.  * This routine cannot be run until the first LoadView(&view) has been
  70.  * executed.  InitGels works with an already active View, so LoadView
  71.  * must have been run first.
  72.  */
  73.  
  74. ReadyGels(g, r)
  75. struct RastPort *r;
  76. struct GelsInfo *g;
  77. {
  78. /* Allocate head and tail of list. */
  79.  
  80.    if ((SpriteHead = (struct VSprite *)AllocMem(sizeof
  81.           (struct VSprite), MEMF_PUBLIC | MEMF_CLEAR)) == 0) {
  82. #ifdef DEBUG
  83.       kprintf("ReadyGels: No memory for sprite head.\n");
  84. #endif
  85.       return(-1);
  86.    }
  87.  
  88.    if ((SpriteTail = (struct VSprite *)AllocMem(sizeof
  89.           (struct VSprite), MEMF_PUBLIC | MEMF_CLEAR)) == 0) {
  90. #ifdef DEBUG
  91.       kprintf("ReadyGels: No memory for sprite tail.\n");
  92. #endif
  93.       return(-1);
  94.    }
  95.  
  96.        /* By setting all bits here, it means that there are NO
  97.    * reserved sprites.  The system can freely use all of the 
  98.    * hardware sprites for its own purposes.  The caller will not be
  99.    * trying to independently use any hardware sprites!
  100.    */
  101.  
  102.    g->sprRsrvd = -1;
  103.  
  104.        /* The nextline array is used to hold system information about
  105.    * "at which line number on the screen is this hardware sprite
  106.    * again going to become available to be given a new vsprite to
  107.    * display".
  108.    */
  109.  
  110.    if ((g->nextLine = (WORD *)AllocMem(sizeof(WORD) * 8,
  111. /**/         MEMF_PUBLIC | MEMF_CLEAR)) == NULL) {
  112. #ifdef DEBUG
  113.       kprintf("ReadyGels: No memory for nextline.\n");
  114. #endif
  115.       return(-1);
  116.    }
  117.  
  118.        /* In the lastcolor pointer array, the system will store
  119.    * a pointer to the color definitions most recently used
  120.    * by the system. .... as a reminder, virtual sprites can
  121.    * be assigned to any of the real hardware sprites which
  122.    * may be available at the time.  The vsprite colors will
  123.    * be written into the hardware sprite register set for
  124.    * the hardware sprite to which that vsprite is assigned.
  125.    * This pointer array contains one pointer to the last
  126.    * set of three colors (from the vsprite structure *sprColors)
  127.    * for each hardware sprite.  
  128.    *
  129.    * As the system is scanning to determine which hardware 
  130.    * sprite should next be used to represent a vsprite, it
  131.    * checks the contents of this array.  If a hardware sprite
  132.    * is available and already has been assigned this set of
  133.    * colors, no color assignment is needed, and therefore
  134.    * no color change instructions will be generated for the
  135.    * copper list.
  136.    *
  137.    * If all vsprites use a different set of sprColors, (pointers
  138.    * to sprColors are different for all vsprites), then there
  139.    * is a limit of 4 vsprites on a horizontal line.  If, on
  140.    * the other hand, you define, lets say 8 vsprites, with
  141.    * 1 and 2 having the same sprColors, 3 and 4 the same as
  142.    * each other, 5 and 6 the same as each other, and 7 and 8
  143.    * also having the same vsprite colors, then you will be
  144.    * able to have all 8 vsprites on the same horizontal line.
  145.    *
  146.    * In this case, you will be able to put all 8 vsprites on
  147.    * the same horizontal line.  The reason this helps is that
  148.    * the system hardware shares the color registers between pairs
  149.    * of hardware sprites.  The system thus has enough resources
  150.    * to assign all vsprites to hardware sprites in that there
  151.    * are 4 color-sets for 8 vsprites, exactly matching the 
  152.    * hardware maximum capabilities.
  153.    *
  154.    * Note that lastcolor will not be used for bobs. Just sprites.
  155.    */
  156.  
  157.    if ((g->lastColor = (WORD **)AllocMem(sizeof(LONG) * 8,
  158.          MEMF_PUBLIC | MEMF_CLEAR)) == NULL) {
  159. #ifdef DEBUG
  160.       kprintf("ReadyGels: No memory for lastcolor.\n");
  161. #endif
  162.       return(-1);
  163.    }
  164.  
  165.        /* This is a table of pointers to the routines which should
  166.    * be performed when DoCollision senses a collision.  This
  167.    * declaration may not be necessary for a basic vsprite with
  168.    * no collision detection implemented, but then it makes for
  169.    * a complete example.
  170.    */
  171.  
  172.    if ((g->collHandler = (struct collTable *)AllocMem(sizeof(struct
  173. /**/         collTable), MEMF_PUBLIC | MEMF_CLEAR)) == NULL) {
  174. #ifdef DEBUG
  175.       kprintf("ReadyGels: No memory for collHandler.\n");
  176. #endif
  177.       return(-1);
  178.    }
  179.  
  180.        /* When any part of the object touches or passes across
  181.    * this boundary, it will cause the boundary collision
  182.    * routine to be called.  This is at smash[0] in the
  183.    * collision handler table and is called only if
  184.    * DoCollision is called.
  185.    */
  186.  
  187.    g->leftmost = 0;
  188.    g->rightmost = r->BitMap->BytesPerRow * 8 - 1;
  189.    g->topmost = 0;
  190.    g->bottommost = r->BitMap->Rows - 1;
  191.  
  192.    r->GelsInfo = g;   /* link together the two structures */
  193.  
  194.    InitGels(SpriteHead, SpriteTail, g );   
  195.  
  196.        /* Pointers initialized to the dummy sprites which will be
  197.    * used by the system to keep track of the animation system.
  198.    */
  199.    SetCollision(0, border_dummy, g);
  200.    WaitTOF();
  201.    return(0);
  202. }
  203.  
  204. /*******************************************************************************
  205.  * Use this to get rid of the gels stuff when it is not needed any more.
  206.  * You must have allocated the gels info stuff (use the ReadyGels routine).
  207.  */
  208.  
  209. PurgeGels(g)
  210. struct GelsInfo *g;
  211. {
  212.    if (g->collHandler != NULL)
  213.       FreeMem(g->collHandler, sizeof(struct collTable));
  214.    if (g->lastColor != NULL)
  215.       FreeMem(g->lastColor, sizeof(LONG) * 8);
  216.    if (g->nextLine != NULL)
  217.       FreeMem(g->nextLine,  sizeof(WORD) * 8);
  218.    if (g->gelHead != NULL)
  219.       FreeMem(g->gelHead, sizeof(struct VSprite));
  220.    if (g->gelTail != NULL)
  221.       FreeMem(g->gelTail, sizeof(struct VSprite));
  222. }
  223.  
  224.  
  225. /******************************************************************************
  226.  * Because MakeVSprite is called by MakeBob, MakeVSprite only creates the
  227.  * VSprite,it doesn't add it to the system list. The calling routine must
  228.  * do an AddVSprite after it is created.
  229.  */
  230.  
  231. struct VSprite *MakeVSprite(lineheight, image, colorset, x, y,
  232.             wordwidth, imagedepth, flags)
  233. SHORT lineheight;   /* how tall is this vsprite? */
  234. WORD *image;      /* where is the vsprite image data, should be
  235.             twice as many words as the value of lineheight */
  236. WORD *colorset;      /* where is the set of three words which describes
  237.             the colors that this vsprite can take on? */
  238. SHORT x, y;      /* what is its initial onscreen position? */
  239. SHORT wordwidth, imagedepth, flags;
  240. {
  241.    struct VSprite *v;   /* make a pointer to the vsprite structure which
  242.                this routine dynamically allocates */
  243.  
  244.    if ((v = (struct VSprite *)AllocMem(sizeof(struct VSprite),
  245.          MEMF_PUBLIC | MEMF_CLEAR)) == 0) {
  246. #ifdef DEBUG
  247.       printf("MakeVSprite: Couldn't allocate VSprite.\n");
  248. #endif
  249.       return(0);
  250.    }
  251.  
  252.    v->Flags = flags;   /* is this a vsprite, not a bob? */
  253.  
  254.    v->Y = y;      /* Establish initial position relative to */
  255.    v->X = x;      /* the Display coordinates. */
  256.  
  257.    v->Height = lineheight;   /* user says how high it is */
  258.    v->Width = wordwidth;   /* a vsprite is always 1 word (16 bits) wide */
  259.  
  260.        /* There are two kinds of depth... the depth of the image itself, and the
  261.    * depth of the playfield into which it will be drawn. The image depth
  262.    * says how much data space will be needed to store an image if it's
  263.    * dynamically allocated. The playfield depth establishes how much space
  264.    * will be needed to save and restore the background when a bob is drawn.
  265.    * A vsprite is always 2 planes deep, but if it's being used to make a
  266.         * bob, it may be deeper...
  267.    */
  268.  
  269.    v->Depth = imagedepth;
  270.  
  271.        /* Assume that user at least has a default boundary collision
  272.    * routine.... bit 1 of this mask is reserved for boundary collision
  273.    * detect during DoCollision(). The only collisions reported will be
  274.    * with the borders. The caller can change all this later.
  275.    */
  276.  
  277.    v->MeMask = 1;
  278.    v->HitMask = 1;
  279.  
  280.    v->ImageData = image;   /* Caller says where to find the image. */
  281.  
  282.        /* Show system where to find a mask which is a squished down version
  283.    * of the vsprite (allows for fast horizontal border collision detect).
  284.    */
  285.  
  286.    if ((v->BorderLine = (WORD *)AllocMem((sizeof(WORD)*wordwidth),
  287. /**/         MEMF_PUBLIC | MEMF_CLEAR)) == 0) {
  288. #ifdef DEBUG
  289.       kprintf("MakeVSprite: Couldn't allocate BorderLine.\n");
  290. #endif
  291.       return(0);
  292.    }
  293.  
  294.        /* Show system where to find the mask which contains a 1 bit for any
  295.    * position in the object in any plane where there is a 1 bit (all planes
  296.    * OR'ed together).
  297.    */
  298.  
  299.    if ((v->CollMask = (WORD *)AllocMem(sizeof(WORD)*lineheight*wordwidth,
  300.          MEMF_CHIP | MEMF_CLEAR)) == 0) {
  301. #ifdef DEBUG
  302.       kprintf("MakeVSprite: Couldn't allocate CollMask.\n");
  303. #endif
  304.       return(0);
  305.    }
  306.  
  307.    /* This isn't used for a Bob, just a VSprite. It's where the
  308.     * Caller says where to find the VSprites colors.
  309.     */
  310.    v->SprColors = colorset;
  311.  
  312.    /* These aren't used for a VSprite, and MakeBob'll do set up for Bob. */
  313.    v->PlanePick = 0x00;
  314.    v->PlaneOnOff = 0x00;
  315.  
  316.    InitMasks(v);   /* create the collMask and borderLine */   
  317.    return(v);
  318. }
  319.  
  320. struct Bob *MakeBob(bitwidth,lineheight,imagedepth,image,
  321.       planePick,planeOnOff, x,y, flags)
  322. SHORT bitwidth,lineheight,imagedepth,planePick,planeOnOff,x,y,flags;
  323. WORD *image;
  324. {
  325.    struct Bob *b;
  326.    struct VSprite *v;
  327.    SHORT wordwidth;
  328.    wordwidth = (bitwidth+15)/16;
  329.  
  330.        /* Create a vsprite for this bob, it will need to be deallocated
  331.    * later (freed) when this bob gets deleted.
  332.    * Note: No color set for bobs.
  333.         */
  334.    if ((v = MakeVSprite(lineheight, image, NULL, x, y, wordwidth,
  335.          imagedepth, flags)) == 0) {
  336. #ifdef DEBUG
  337.       kprintf("MakeBob: MakeVSprite failed.\n");
  338. #endif
  339.       return(0);
  340.    }
  341.  
  342.    /* Caller selects which bit planes into which the image is drawn. */
  343.    v->PlanePick = planePick;
  344.  
  345.    /* What happens to the bit planes into which the image is not drawn. */
  346.    v->PlaneOnOff = planeOnOff;
  347.  
  348.    if ((b = (struct Bob *)AllocMem(sizeof(struct Bob),
  349.          MEMF_PUBLIC | MEMF_CLEAR)) == 0) {
  350. #ifdef DEBUG
  351.       kprintf("MakeBob: Couldn't allocate bob.\n");
  352. #endif
  353.       return(0);
  354.    }
  355.  
  356.    v->VSBob = b;   /* Link together the bob and its vsprite structures */
  357.  
  358.    b->Flags = 0; /* Not part of an animation (BOBISCOMP) and don't keep the
  359.          image present after bob is removed (SAVEBOB) */ 
  360.  
  361.        /* Tell where to save background. Must have enough space for as many
  362.    * bitplanes deep as the display into which everything is being drawn.
  363.    */
  364.  
  365.    if ((b->SaveBuffer = (WORD *)AllocMem(sizeof(SHORT) * wordwidth
  366. /**/       * lineheight * imagedepth, MEMF_CHIP | MEMF_CLEAR)) == 0) {
  367. #ifdef DEBUG
  368.       kprintf("MakeBob: Couldn't allocate save buffer.\n");
  369. #endif
  370.       return(0);
  371.    }
  372.  
  373.    b->ImageShadow = v->CollMask;
  374.  
  375.        /* Interbob priorities are set such that the earliest defined bobs have
  376.    * the lowest priority, last bob defined is on top.
  377.    */
  378.  
  379.    b->Before = NULL;   /* Let the caller worry about priority later. */
  380.    b->After = NULL;
  381.  
  382.    b->BobVSprite = v;
  383.  
  384.        /* InitMasks does not preset the imageShadow ... user may elect to use
  385.    * the collMask or to create his own version of a shadow, although it
  386.    * is usually the same.
  387.    */
  388.  
  389.    b->BobComp = NULL;   /* this is not part of an animation */
  390.    b->DBuffer = NULL;   /* this is not double buffered */
  391.  
  392.        /* Return a pointer to this newly created bob for additional caller
  393.    * interaction or for AddBob(b);
  394.    */
  395.    return(b);
  396. }
  397.  
  398. /* Deallocate memory which has been allocated by the routine MakeGel. */
  399. /* assumes images and imageshadow deallocated elsewhere */
  400. DeleteGel(v)
  401. struct VSprite *v;
  402. {
  403.    if (v != NULL) {
  404.       if (v->VSBob != NULL) {
  405.          if (v->VSBob->SaveBuffer != NULL) {
  406.             FreeMem(v->VSBob->SaveBuffer, sizeof(SHORT) * v->Width
  407.                   * v->Height * v->Depth);
  408.          }
  409.          if (v->VSBob->DBuffer != NULL) {
  410.             if (v->VSBob->DBuffer->BufBuffer != 0) {
  411.                FreeMem(v->VSBob->DBuffer->BufBuffer,
  412.                      sizeof(SHORT) * v->Width * v->Height * v->Depth);
  413.             }
  414.             FreeMem(v->VSBob->DBuffer, sizeof(struct DBufPacket));
  415.          }
  416.          FreeMem( v->VSBob, sizeof(struct Bob));
  417.       }
  418.       if (v->CollMask != NULL) {
  419.          FreeMem(v->CollMask, sizeof(WORD) * v->Height * v->Width);
  420.       }
  421.       if (v->BorderLine != NULL) {
  422.          FreeMem(v->BorderLine, sizeof(WORD) * v->Width);
  423.       }
  424.       FreeMem(v, sizeof(struct VSprite));
  425.    }
  426. }
  427.